const express = require('express');
const router = express.Router();
const { Op } = require('sequelize');
const { createSuccessResponse } = require('../../middleware/responseHandler.js');
const { voteModel, getCreateDefaults, getUpdateDefaults } = require('../../models/vote.js');

// ==================== 投票相关接口 ====================
/**
 * 本页面主要方法有：
 * 1.创建投票
 * 2.删除投票
 * 3.查询投票
 * 4.修改投票
 * 5.投票统计
 * 6.状态切换
 */

// ==================== 路由定义 ====================

/**
 * 创建投票
 * @param {Object} voteData - 投票数据
 * @returns {Promise<object>} 返回创建的投票信息
 * 逻辑:
 * 1.验证投票数据
 * 2.创建投票记录
 * 3.返回投票信息
 */
router.post("/createVote", (req, res, next) => {
    const {
        user_id = 0,
        title = '',
        sub_title = '',
        keywords = '',
        content = '',
        is_normal = 0,
        type = 0,
        rules = '',
        color_style = 0,
        background_image = '',
        header_image = '',
        list_style = 0,
        page_style = 0,
        auto_verify = 0,
        is_prefix = 0,
        is_seed = 0,
        is_seed_sort = 0,
        is_vote_start = 0,
        vote_start_time = 0,
        vote_end_time = 0,
        is_apply_start = 0,
        apply_start_time = 0,
        apply_end_time = 0,
        total_count = 0,
        day_count = 0,
        total_extra_count = 0,
        day_extra_count = 0
    } = req.body;

    // 参数验证
    if (!title) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '投票标题不能为空',
            error: '投票标题不能为空',
            timestamp: Date.now()
        });
    }

    if (!user_id) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '用户ID不能为空',
            error: '用户ID不能为空',
            timestamp: Date.now()
        });
    }

    // 验证时间参数
    if (vote_start_time && vote_end_time && vote_start_time >= vote_end_time) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '投票结束时间必须大于开始时间',
            error: '投票结束时间必须大于开始时间',
            timestamp: Date.now()
        });
    }

    if (apply_start_time && apply_end_time && apply_start_time >= apply_end_time) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '报名结束时间必须大于开始时间',
            error: '报名结束时间必须大于开始时间',
            timestamp: Date.now()
        });
    }

    // 构建创建数据
    const createData = {
        user_id: parseInt(user_id),
        title,
        sub_title,
        keywords,
        content,
        is_normal: parseInt(is_normal),
        type: parseInt(type),
        rules,
        color_style: parseInt(color_style),
        background_image,
        header_image,
        list_style: parseInt(list_style),
        page_style: parseInt(page_style),
        auto_verify: parseInt(auto_verify),
        is_prefix: parseInt(is_prefix),
        is_seed: parseInt(is_seed),
        is_seed_sort: parseInt(is_seed_sort),
        is_vote_start: parseInt(is_vote_start),
        vote_start_time: parseInt(vote_start_time),
        vote_end_time: parseInt(vote_end_time),
        is_apply_start: parseInt(is_apply_start),
        apply_start_time: parseInt(apply_start_time),
        apply_end_time: parseInt(apply_end_time),
        total_count: parseInt(total_count),
        day_count: parseInt(day_count),
        total_extra_count: parseInt(total_extra_count),
        day_extra_count: parseInt(day_extra_count),
        ...getCreateDefaults()
    };

    // 创建投票记录
    voteModel.create(createData)
        .then(newVote => {
            res.json(createSuccessResponse(newVote, '投票创建成功'));
        })
        .catch(error => {
            console.error('创建投票错误:', error);
            next(error);
        });
});

/**
 * 删除投票（软删除）
 * @param {number|Array} vote_id - 投票ID或投票ID数组
 * @returns {Promise<object>} 返回删除结果
 * 逻辑:
 * 1.验证投票ID
 * 2.检查投票是否存在
 * 3.软删除投票记录
 * 4.返回删除结果
 */
router.post("/deleteVote", (req, res, next) => {
    const { vote_id } = req.body;

    // 参数验证
    if (!vote_id) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '投票ID不能为空',
            error: '投票ID不能为空',
            timestamp: Date.now()
        });
    }

    // 判断是单个删除还是批量删除
    const isBatchDelete = Array.isArray(vote_id);

    if (isBatchDelete) {
        // 批量删除逻辑
        if (vote_id.length === 0) {
            return res.status(200).json({
                success: false,
                code: 400,
                message: '投票ID数组不能为空',
                error: '投票ID数组不能为空',
                timestamp: Date.now()
            });
        }

        // 验证所有ID都是有效的
        const validIds = vote_id.filter(id => !isNaN(parseInt(id)));
        if (validIds.length !== vote_id.length) {
            return res.status(200).json({
                success: false,
                code: 400,
                message: '存在无效的投票ID',
                error: '存在无效的投票ID',
                timestamp: Date.now()
            });
        }

        // 批量软删除
        voteModel.update({
            is_delete: 1,
            ...getUpdateDefaults()
        }, {
            where: {
                vote_id: {
                    [Op.in]: validIds
                },
                is_delete: 0
            }
        }).then(result => {
            res.json(createSuccessResponse({
                deleted_count: result[0],
                vote_ids: validIds,
                delete_time: Math.floor(Date.now() / 1000)
            }, `成功删除 ${result[0]} 个投票`));
        }).catch(error => {
            console.error('批量删除投票错误:', error);
            next(error);
        });
    } else {
        // 单个删除逻辑
        if (isNaN(parseInt(vote_id))) {
            return res.status(200).json({
                success: false,
                code: 400,
                message: '投票ID无效',
                error: '投票ID无效',
                timestamp: Date.now()
            });
        }

        // 检查投票是否存在
        voteModel.findOne({
            where: {
                vote_id: parseInt(vote_id),
                is_delete: 0
            }
        }).then(existingVote => {
            if (!existingVote) {
                return res.status(200).json({
                    success: false,
                    code: 404,
                    message: '投票不存在',
                    error: '投票不存在',
                    timestamp: Date.now()
                });
            }

            // 软删除投票记录
            return existingVote.update({
                is_delete: 1,
                ...getUpdateDefaults()
            });
        }).then(deletedVote => {
            res.json(createSuccessResponse({
                vote_id: deletedVote.vote_id,
                title: deletedVote.title,
                delete_time: Math.floor(Date.now() / 1000)
            }, '投票删除成功'));
        }).catch(error => {
            console.error('删除投票错误:', error);
            next(error);
        });
    }
});

/**
 * 查询投票列表
 * @param {Object} queryParams - 查询参数
 * @returns {Promise<object>} 返回投票列表
 * 逻辑:
 * 1.解析查询参数
 * 2.根据参数查询投票
 * 3.返回投票信息
 */
router.post("/getVoteList", (req, res, next) => {
    const {
        page = 1,
        pageSize = 10,
        keyword = '',
        type = '',
        is_normal = '',
        user_id = '',
        is_vote_start = '',
        is_apply_start = ''
    } = req.body;

    // 构建查询条件
    const where = {
        is_delete: 0
    };

    // 关键词搜索
    if (keyword) {
        where[Op.or] = [
            { title: { [Op.like]: `%${keyword}%` } },
            { sub_title: { [Op.like]: `%${keyword}%` } },
            { keywords: { [Op.like]: `%${keyword}%` } }
        ];
    }

    // 投票类型筛选
    if (type !== '') {
        where.type = parseInt(type);
    }

    // 正式状态筛选
    if (is_normal !== '') {
        where.is_normal = parseInt(is_normal);
    }

    // 用户筛选
    if (user_id) {
        where.user_id = parseInt(user_id);
    }

    // 投票开关筛选
    if (is_vote_start !== '') {
        where.is_vote_start = parseInt(is_vote_start);
    }

    // 报名开关筛选
    if (is_apply_start !== '') {
        where.is_apply_start = parseInt(is_apply_start);
    }

    // 分页参数
    const offset = (parseInt(page) - 1) * parseInt(pageSize);
    const limit = parseInt(pageSize);

    // 查询投票列表
    voteModel.findAndCountAll({
        where,
        order: [['create_time', 'DESC']],
        limit,
        offset,
        attributes: [
            'vote_id',
            'user_id',
            'title',
            'sub_title',
            'keywords',
            'content',
            'is_normal',
            'type',
            'color_style',
            'background_image',
            'header_image',
            'list_style',
            'page_style',
            'auto_verify',
            'is_prefix',
            'is_seed',
            'is_seed_sort',
            'is_vote_start',
            'vote_start_time',
            'vote_end_time',
            'is_apply_start',
            'apply_start_time',
            'apply_end_time',
            'total_count',
            'day_count',
            'total_extra_count',
            'day_extra_count',
            'create_time',
            'update_time'
        ]
    }).then(({ count, rows }) => {
        const totalPages = Math.ceil(count / limit);
        const data = {
            list: rows,
            pagination: {
                page: parseInt(page),
                pageSize: limit,
                total: count,
                totalPages: totalPages,
                hasNext: parseInt(page) < totalPages,
                hasPrev: parseInt(page) > 1
            }
        };

        res.json(createSuccessResponse(data, '查询投票成功'));
    }).catch(error => {
        console.error('查询投票列表错误:', error);
        next(error);
    });
});

/**
 * 根据ID查询投票详情
 * @param {number} vote_id - 投票ID
 * @returns {Promise<object>} 返回投票详情
 */
router.post("/getVoteById", (req, res, next) => {
    const { vote_id } = req.body;
    // 参数验证
    if (!vote_id || isNaN(parseInt(vote_id))) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '投票ID无效',
            error: '投票ID无效',
            timestamp: Date.now()
        });
    }

    // 查询投票详情
    voteModel.findOne({
        where: {
            vote_id: parseInt(vote_id),
            is_delete: 0
        },
        attributes: [
            'vote_id',
            'user_id',
            'title',
            'sub_title',
            'keywords',
            'content',
            'is_normal',
            'type',
            'rules',
            'color_style',
            'background_image',
            'header_image',
            'list_style',
            'page_style',
            'auto_verify',
            'is_prefix',
            'is_seed',
            'is_seed_sort',
            'is_vote_start',
            'vote_start_time',
            'vote_end_time',
            'is_apply_start',
            'apply_start_time',
            'apply_end_time',
            'total_count',
            'day_count',
            'total_extra_count',
            'day_extra_count',
            'create_time',
            'update_time'
        ]
    }).then(voteDetail => {
        if (!voteDetail) {
            return res.status(200).json({
                success: false,
                code: 404,
                message: '投票不存在',
                error: '投票不存在',
                timestamp: Date.now()
            });
        }

        res.json(createSuccessResponse(voteDetail, '获取投票详情成功'));
    }).catch(error => {
        console.error('查询投票详情错误:', error);
        next(error);
    });
});

/**
 * 修改投票
 * @param {number} vote_id - 投票ID
 * @param {Object} updateData - 更新数据
 * @returns {Promise<object>} 返回更新后的投票信息
 * 逻辑:
 * 1.验证投票ID和更新数据
 * 2.检查投票是否存在
 * 3.更新投票信息
 * 4.返回更新后的投票信息
 */
router.post("/updateVote", (req, res, next) => {
    const {
        vote_id,
        user_id,
        title,
        sub_title,
        keywords,
        content,
        is_normal,
        type,
        rules,
        color_style,
        background_image,
        header_image,
        list_style,
        page_style,
        auto_verify,
        is_prefix,
        is_seed,
        is_seed_sort,
        is_vote_start,
        vote_start_time,
        vote_end_time,
        is_apply_start,
        apply_start_time,
        apply_end_time,
        total_count,
        day_count,
        total_extra_count,
        day_extra_count
    } = req.body;

    // 参数验证
    if (!vote_id || isNaN(parseInt(vote_id))) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '投票ID无效',
            error: '投票ID无效',
            timestamp: Date.now()
        });
    }

    // 检查投票是否存在
    voteModel.findOne({
        where: {
            vote_id: parseInt(vote_id),
            is_delete: 0
        }
    }).then(existingVote => {
        if (!existingVote) {
            return res.status(200).json({
                success: false,
                code: 404,
                message: '投票不存在',
                error: '投票不存在',
                timestamp: Date.now()
            });
        }

        // 构建更新数据
        const updateData = {
            ...getUpdateDefaults()
        };

        // 只更新提供的字段
        const allowedFields = [
            'user_id', 'title', 'sub_title', 'keywords', 'content',
            'is_normal', 'type', 'rules', 'color_style', 'background_image',
            'header_image', 'list_style', 'page_style', 'auto_verify',
            'is_prefix', 'is_seed', 'is_seed_sort', 'is_vote_start',
            'vote_start_time', 'vote_end_time', 'is_apply_start',
            'apply_start_time', 'apply_end_time', 'total_count',
            'day_count', 'total_extra_count', 'day_extra_count'
        ];

        allowedFields.forEach(field => {
            if (req.body[field] !== undefined) {
                // 数值字段需要转换
                if (['user_id', 'is_normal', 'type', 'color_style', 'list_style',
                    'page_style', 'auto_verify', 'is_prefix', 'is_seed', 'is_seed_sort',
                    'is_vote_start', 'vote_start_time', 'vote_end_time', 'is_apply_start',
                    'apply_start_time', 'apply_end_time', 'total_count', 'day_count',
                    'total_extra_count', 'day_extra_count'].includes(field)) {
                    updateData[field] = parseInt(req.body[field]) || 0;
                } else {
                    updateData[field] = req.body[field];
                }
            }
        });

        // 更新投票信息
        return existingVote.update(updateData);
    }).then(updatedVote => {
        res.json(createSuccessResponse(updatedVote, '投票修改成功'));
    }).catch(error => {
        console.error('修改投票错误:', error);
        next(error);
    });
});

/**
 * 获取投票统计信息
 * @param {number} user_id - 用户ID（可选）
 * @returns {Promise<object>} 返回统计信息
 */
router.post("/getVoteStats", (req, res, next) => {
    const { user_id } = req.body;

    const where = {
        is_delete: 0
    };

    if (user_id) {
        where.user_id = parseInt(user_id);
    }

    // 获取各种统计信息
    Promise.all([
        // 总投票数
        voteModel.count({ where }),
        // 正式投票数
        voteModel.count({ where: { ...where, is_normal: 1 } }),
        // 测试投票数
        voteModel.count({ where: { ...where, is_normal: 0 } }),
        // 开启投票的投票数
        voteModel.count({ where: { ...where, is_vote_start: 1 } }),
        // 开启报名的投票数
        voteModel.count({ where: { ...where, is_apply_start: 1 } })
    ]).then(([total, formal, test, voteStarted, applyStarted]) => {
        res.json(createSuccessResponse({
            total,
            formal,
            test,
            voteStarted,
            applyStarted,
            stats_time: Math.floor(Date.now() / 1000)
        }, '获取投票统计成功'));
    }).catch(error => {
        console.error('获取投票统计错误:', error);
        next(error);
    });
});

/**
 * 切换投票状态
 * @param {number} vote_id - 投票ID
 * @param {string} action - 操作类型（vote_start, vote_stop, apply_start, apply_stop）
 * @returns {Promise<object>} 返回操作结果
 */
router.post("/toggleVoteStatus", (req, res, next) => {
    const { vote_id, action } = req.body;

    // 参数验证
    if (!vote_id || isNaN(parseInt(vote_id))) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '投票ID无效',
            error: '投票ID无效',
            timestamp: Date.now()
        });
    }

    if (!['vote_start', 'vote_stop', 'apply_start', 'apply_stop'].includes(action)) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '操作类型无效',
            error: '操作类型无效',
            timestamp: Date.now()
        });
    }

    // 确定要更新的字段和值
    let updateField, updateValue;
    switch (action) {
        case 'vote_start':
            updateField = 'is_vote_start';
            updateValue = 1;
            break;
        case 'vote_stop':
            updateField = 'is_vote_start';
            updateValue = 0;
            break;
        case 'apply_start':
            updateField = 'is_apply_start';
            updateValue = 1;
            break;
        case 'apply_stop':
            updateField = 'is_apply_start';
            updateValue = 0;
            break;
    }

    // 更新投票状态
    voteModel.findOne({
        where: {
            vote_id: parseInt(vote_id),
            is_delete: 0
        }
    }).then(existingVote => {
        if (!existingVote) {
            return res.status(200).json({
                success: false,
                code: 404,
                message: '投票不存在',
                error: '投票不存在',
                timestamp: Date.now()
            });
        }

        return existingVote.update({
            [updateField]: updateValue,
            ...getUpdateDefaults()
        });
    }).then(updatedVote => {
        const actionText = {
            'vote_start': '开启投票',
            'vote_stop': '停止投票',
            'apply_start': '开启报名',
            'apply_stop': '停止报名'
        }[action];

        res.json(createSuccessResponse({
            vote_id: updatedVote.vote_id,
            title: updatedVote.title,
            [updateField]: updateValue,
            action: action
        }, `${actionText}成功`));
    }).catch(error => {
        console.error('切换投票状态错误:', error);
        next(error);
    });
});

module.exports = router;
